/*
 *Description:
 *User:laoHu
 *Created with Intellij IDEA 2025
 *Data:2025.06.04
 *Time:14:43
 */

import Demo1.Animal;
import Demo1.Bird;
import Demo1.Dog;
import Demo1.Person;
import Demo2.B;
import Demo2.A;
import Demo3.Cycle;
import Demo3.Shape;
import Demo3.Square;
import Demo3.Triangle;

import java.util.concurrent.Callable;


public class Main{

    //多态的优点：降低圈复杂的（分支与循环的个数）
    public static void main(String[] args) {

//        Shape shape = new Square();
//        Shape shape1 = new Triangle();
//        Shape shape2 = new Cycle();

//        String[] arrays = {"square", "triangle", "square", "triangle", "cycle"};
        //法一
        //for (int i = 0; i < arrays.length; i++) {
//            String shapex = arrays[i];
//            if(shape.equals("square")){
//                shape.print();
//            }else if(shapex.equals("triangle")){
//                shape1.print();
//            }else{
//                shape2.print();
//            }
//        }
            //法二：
//            for (String shapex : arrays) {
//
//                if (shape.equals("square")) {
//                    shape.print();
//                } else if (shapex.equals("triangle")) {
//                    shape1.print();
//                } else {
//                    shape2.print();
//                }
//            }

        //法三：多态的使用
        Square square =new Square();
        Triangle triangle =new Triangle();
        Cycle cycle = new Cycle();

        Shape[] arrays = {square, triangle, square, triangle, cycle};
        for(Shape shape : arrays){
            shape.print();
        }
    }

    //有坑的代码
    public static void main8(String[] args) {
        //虽然构成重写，但是是在构造方法完成前调用，使用的还是子类的方法
        B b = new B();
        b.fun1();
    }

    //重写的toString引用子类是因为发生了动态绑定
    //默认继承了object的父类
    public static void main7(String[] args) {

        Animal animal = new Person("老王",22);

        System.out.println(animal);//输出子类的重写方法
    }


    //向下转型
    public static void main6(String[] args) {
        Animal animal = new Dog("偶偶",5);

        //向下转型
       Dog animal1 = (Dog)animal;
       animal1.eat();//不会报错，因为引用指向的类就是Dog
        //java: 不兼容的类型: Demo1.Dog无法转换为Demo1.Bird
       //Bird animal2 = (Dog)animal;//无法编译
       // animal2.eat();
    }

    //不构成重写的方法
    public static void main5(String[] args) {
      Animal animal = new Dog("埃昂",1);
      Animal animal1 = new Bird("一一",2);

      Dog dog = (Dog)animal;//向下转型
      //不能重写，调用父类
        animal.walk();
        dog.wolk();//可以调用Dog的成员方法
        animal1.running();
         //animal.serach();//报错
    }

//访问权限:构成重写的，子类的访问修饰词的权限大于等于父类
public static void main4(String[] args) {
  Dog dog = new Dog("哈哈",2);
  Animal animal1 = new Bird("满满",5);
  //sleep构成重写
   dog.sleep();
  //fly构成重写,但是父类的权限高于子类导致错误
    //java: Demo1.Bird中的fly()无法覆盖Demo1.Animal中的fly()
    animal1.fly();
}

    //向上转型;3.返回值
    public static Animal func(int a){

        if(a == 1){
            return new Dog("六六",5);
        }else {
            return new Bird("芬芳",6);
        }
    }

    public static void main3(String[] args) {

        Animal animal = func(1);
        animal.eat();
        animal = func(0);
        animal.eat();
    }

    //向上转型：2.函数传参
   public static void fun(Animal animal){
       animal.eat();
   }
    public static void main2(String[] args) {
        Dog dog = new Dog("小丁",2);
        Bird bird = new Bird("小小",4);
        //发生动态绑定:同一个引用，当引用指向的对象不同时，
        //调用的成员方法产生的效果也不一样，此时就发生了多态
        fun(dog);
        fun(bird);
    }

    public static void main1(String[] args) {

        //向上转型：1.直接传值
        Animal animal = new Dog("旺财",3);

        //发生动态绑定
        animal.eat();//实际调用了子类的方法
        //1.使用父类引用指向子类实例的对象
        //2.父类和子类发方法发生重写
        //3.使用父类的引用调用重新的方法
    }
}